A compiler is a computer program that translates source code conforming to a programming language into object code conforming to another language. In many instances, the object code is machine code that can be directly executed by a physical machine, such as a central processing unit (CPU). For example, the object code may include a set of binary instructions that can be directly loaded and executed by the CPU. The object code is typically much more difficult for a human user to read and understand than the programming language code, but enables the target machine to carry out the instructions specified in the source code.
Traditional compilers that compile legacy source code bases, such as code conforming to the C programming language, rely on ahead-of-time (AOT) compilation, also known as static compilation, to generate object code. AOT compilers translate the source code of a particular program into machine code before the program begins execution. This approach avoids any potential latencies associated with run-time compilation and conserves resources associated with the run-time environment. However, the pre-compiled code must be fully functional and cannot be optimized using runtime information.
Another approach to compiling source code involves “just-in-time” (JIT) compilation, also referred to as dynamic translation. This approach is used for more modern and dynamic programming languages, such as code conforming to the Java® programming language. Specifically, Java® source code is compiled to bytecode that can be run on any Java® Virtual Machine (JVM) regardless of the CPU architecture of the computer executing the JVM. During program execution, the JVM executes the bytecode by using a JIT compiler to dynamically convert the bytecode instructions into native machine code. In contrast to AOT compilers, the JIT compiler is able to accomplish performance boosts by analyzing runtime feedback to optimize the machine code based on the current program state.
Many large source code bases were initially written in static programming languages and optimized for specific AOT compilers. While the benefits of dynamic translation could potentially provide further optimizations to these legacy source code bases, rewriting the source code bases into a dynamic programming language would require enormous overhead and nullify many of the AOT-specific optimizations.
In order to leverage the benefits of JIT compilation, some runtime environments are configured to apply dynamic compilation techniques to static languages. According to one such approach, a virtual machine (VM) uses an AOT compiler as a backend compiler. Specifically, the virtual machine, which executes a dynamic programming language, profiles the code and produces optimized C code based on the runtime information. The VM then invokes a traditional AOT C compiler to generate compiled code. The VM treats the C compiler as a black box. Thus, the optimizations are limited to the source code and cannot be fine-tuned at the machine code layer. In addition, this approach relies on the source code initially being written in a dynamic programming language, and the overhead from constantly generating optimized C code can be significant.
The approaches described in this section are approaches that could be pursued, but not necessarily approaches that have been previously conceived or pursued. Therefore, unless otherwise indicated, it should not be assumed that any of the approaches described in this section qualify as prior art merely by virtue of their inclusion in this section.